package com.blrs.service.project.planning.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;

import com.blrs.common.enums.UseTypeEnum;
import com.blrs.common.utils.SecurityUtils;
import com.blrs.domain.ProjectBudget;
import com.blrs.domain.ProjectMember;
import com.blrs.domain.ProjectPlanning;
import com.blrs.domain.dto.ProcessDTO;
import com.blrs.domain.dto.ProjectPlanningDTO;
import com.blrs.domain.vo.*;
import com.blrs.factory.FlowServiceFactory;
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.runtime.ProcessInstance;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.blrs.mapper.ProjectPlanningMapper;
import com.blrs.mapper.ProjectMemberMapper;
import com.blrs.mapper.ProjectProcessMapper;
import com.blrs.service.project.planning.IProjectPlanningService;
import com.blrs.mapper.ProjectBudgetMapper;
import com.blrs.mapper.ProjectDeliverableMapper;

/**
 * 项目策划服务实现类
 */
@Slf4j
@Service
public class ProjectPlanningServiceImpl implements IProjectPlanningService {

//    @Autowired
//    private ProjectPlanningMapper planningMapper;
//
//    @Autowired
//    private ProjectMemberMapper memberMapper;
//
//    @Autowired
//    private ProjectProcessMapper processMapper;
//
//    @Autowired
//    private ProjectBudgetMapper budgetMapper;
//
//    @Autowired
//    private ProjectDeliverableMapper deliverableMapper;
//
//    @Autowired
//    private FlowServiceFactory flowServiceFactory;
//
//    /**
//     * 新增项目策划
//     * 默认会插入所有用途类型(策划、模版、实施)的数据
//     * 如需选择性插入特定类型，请使用insertWithTypes方法
//     *
//     * @param planningDTO 项目策划信息
//     * @return 影响行数
//     */
//    @Override
//    @Transactional
//    public int insertProjectPlanning(ProjectPlanningDTO planningDTO) {
//        // 1. 生成策划ID
//        String planningId = UUID.randomUUID().toString();
//
//        // 2. 插入策划主表
//        ProjectPlanning planning = new ProjectPlanning();
//        planning.setPlanningId(planningId);
//        planning.setProjectId(planningDTO.getProjectId());
//        planning.setAuditState("0"); // 未审核
//        planning.setDelFlag("0"); // 未删除
//        planning.setCreationId(SecurityUtils.getUserId());
//        planning.setCreationName(SecurityUtils.getUsername());
//        int rows = planningMapper.insertProjectPlanning(planning);
//        // 3. 插入单个用途类型示例：
//        //List<Integer> planningTypes = Arrays.asList(UseTypeEnum.PLANNING.getCode());
//
//        // 4. 插入多个用途类型示例：
//        //List<Integer> planningTypes = Arrays.asList(UseTypeEnum.PLANNING.getCode(), UseTypeEnum.TEMPLATE.getCode());
//
//        // 5. 插入项目成员、工艺及预算 (默认插入所有类型)
//        List<Integer> planningTypes = UseTypeEnum.getAllCodes();
//        insertMembers(planningDTO.getMembers(), planningId, planningTypes);
//        insertProcessesAndDeliverables(planningDTO.getProcesses(), planningId, planningTypes);
//        insertBudgets(planningDTO.getBudgets(), planningId, planningTypes);
//
//        return rows;
//    }
//
//    /**
//     * 插入指定用途类型的数据
//     * 可以选择性地只插入某些用途类型的数据
//     *
//     * @param planningDTO 项目策划信息
//     * @param planningId 策划ID
//     * @param types 指定的用途类型，例如：UseTypeEnum.PLANNING, UseTypeEnum.TEMPLATE
//     */
//    @Transactional
//    public void insertWithTypes(ProjectPlanningDTO planningDTO, String planningId, UseTypeEnum... types) {
//        List<Integer> useTypes = new ArrayList<>();
//        for (UseTypeEnum type : types) {
//            useTypes.add(type.getCode());
//        }
//
//        insertMembers(planningDTO.getMembers(), planningId, useTypes);
//        insertProcessesAndDeliverables(planningDTO.getProcesses(), planningId, useTypes);
//        insertBudgets(planningDTO.getBudgets(), planningId, useTypes);
//    }
//
//    /**
//     * 删除指定用途类型的数据
//     * 可以选择性地只删除某些用途类型的数据
//     *
//     * @param planningId 策划ID
//     * @param types 指定的用途类型，例如：UseTypeEnum.PLANNING, UseTypeEnum.TEMPLATE
//     */
//    @Transactional
//    public void deleteWithTypes(String planningId, UseTypeEnum... types) {
//        List<Integer> useTypes = new ArrayList<>();
//        for (UseTypeEnum type : types) {
//            useTypes.add(type.getCode());
//        }
//
//        memberMapper.deleteProjectMemberByPlanningId(planningId, useTypes);
//        deliverableMapper.deleteProjectDeliverableByPlanningId(planningId, useTypes);
//        processMapper.deleteProjectProcessByPlanningId(planningId, useTypes);
//        budgetMapper.deleteProjectBudgetByPlanningId(planningId, useTypes);
//    }
//
//    /**
//     * 更新项目策划
//     * 默认更新所有用途类型(策划、模版、实施)的数据
//     * 如需选择性更新特定类型，请使用deleteWithTypes和insertWithTypes方法组合
//     *
//     * @param planningDTO 项目策划信息
//     * @return 影响行数
//     */
//    @Override
//    @Transactional
//    public int updateProjectPlanning(ProjectPlanningDTO planningDTO) {
//        // 1. 更新策划主表
//        ProjectPlanning planning = new ProjectPlanning();
//        planning.setPlanningId(planningDTO.getPlanningId());
//        planning.setAuditState(planningDTO.getAuditState());
//        planning.setOperateId(SecurityUtils.getUserId());
//        planning.setOperateName(SecurityUtils.getUsername());
//        int rows = planningMapper.updateProjectPlanning(planning);
//
//        String planningId = planningDTO.getPlanningId();
//
//        // 2. 删除并重新插入所有类型数据
//        deleteWithTypes(planningId, UseTypeEnum.values());
//        insertWithTypes(planningDTO, planningId, UseTypeEnum.values());
//
//        return rows;
//    }
//
//    /**
//     * 插入项目成员数据
//     * 根据指定的用途类型列表，为每个成员生成对应类型的数据
//     *
//     * @param members 项目成员列表
//     * @param planningId 策划ID
//     * @param useTypes 用途类型列表
//     */
//    private void insertMembers(List<ProjectMember> members, String planningId, List<Integer> useTypes) {
//        if (members != null && useTypes != null) {
//            members.forEach(member -> {
//                for (Integer useType : useTypes) {
//                    member.setPlanningId(planningId);
//                    member.setUserId(member.getUserId());
//                    member.setMemberId(UUID.randomUUID().toString());
//                    member.setUseType(useType);
//                    memberMapper.insertProjectMember(member);
//                }
//            });
//        }
//    }
//
//    /**
//     * 插入工艺及交付物数据
//     * 根据指定的用途类型列表，为每个工艺和其关联的交付物生成对应类型的数据
//     *
//     * @param processes 工艺列表(包含交付物)
//     * @param planningId 策划ID
//     * @param useTypes 用途类型列表
//     */
//    private void insertProcessesAndDeliverables(List<ProcessDTO> processes, String planningId, List<Integer> useTypes) {
//        if (processes != null && useTypes != null) {
//            processes.forEach(process -> {
//                for (Integer useType : useTypes) {
//                    process.setPlanningId(planningId);
//                    process.setProcessId(UUID.randomUUID().toString());
//                    process.setExecutorPerson(process.getExecutorPerson());
//                    process.setUseType(useType);
//                    process.setStatus(0);
//                    processMapper.insertProjectProcess(process);
//
//                    if (process.getDeliverables() != null) {
//                        process.getDeliverables().forEach(deliverable -> {
//                            deliverable.setDeliverableId(UUID.randomUUID().toString());
//                            deliverable.setProcessId(process.getProcessId());
//                            deliverable.setUseType(useType);
//                            deliverableMapper.insertProjectDeliverable(deliverable);
//                        });
//                    }
//                }
//            });
//        }
//    }
//
//    /**
//     * 插入预算数据
//     * 根据指定的用途类型列表，为每个预算生成对应类型的数据
//     *
//     * @param budgets 预算列表
//     * @param planningId 策划ID
//     * @param useTypes 用途类型列表
//     */
//    private void insertBudgets(List<ProjectBudget> budgets, String planningId, List<Integer> useTypes) {
////        if (budgets != null && useTypes != null) {
////            budgets.forEach(budget -> {
////                for (Integer useType : useTypes) {
////                    budget.setPlanningId(planningId);
////                    budget.setBudgetId(UUID.randomUUID().toString());
////                    budget.setUseType(useType);
////                    budgetMapper.insertProjectBudget(budget);
////                }
////            });
////        }
//    }
//
//    /**
//     * 查询项目策划列表
//     *
//     * @param planningDTO 查询条件
//     * @return 项目策划列表
//     */
//    @Override
//    public List<ProjectPlanningVO> selectProjectPlanningList(ProjectPlanningDTO planningDTO) {
//        return planningMapper.selectProjectPlanningList(planningDTO);
//    }
//
//    /**
//     * 根据ID查询项目策划详情
//     * 包括基本信息、项目成员、工艺及交付物、预算等
//     *
//     * @param planningId 策划ID
//     * @param useType 用途类型
//     * @return 项目策划详情
//     */
//    @Override
//    public ProjectPlanningVO selectProjectPlanningById(String planningId, Integer useType) {
//        // 查询策划基本信息
//        ProjectPlanningVO planning = planningMapper.selectProjectPlanningById(planningId);
//        if (planning != null) {
//            // 查询项目成员 (useType=1 策划)
//            List<ProjectMemberVO> members = memberMapper.selectMembersByPlanningId(planningId, useType);
//            planning.setMembers(members);
//
//            // 查询实施工艺及交付物 (useType=1 策划)
//            List<ProcessVO> processes = processMapper.selectProcessesByPlanningId(planningId, useType);
//            planning.setProcesses(processes);
//
//            // 查询费用预算 (useType=1 策划)
//            List<BudgetVO> budgets = budgetMapper.selectBudgetsByPlanningId(planningId, useType);
//            planning.setBudgets(budgets);
//        }
//        return planning;
//    }
//
//    /**
//     * 根据产品ids查询工艺模板
//     *
//     * @param productIds 产品ids，多个id用逗号分隔
//     * @return 工艺模板列表
//     */
//    @Override
//       public List<ProcessTemplateVO> selectProcessTemplateByProductIds(String productIds) {
//        return planningMapper.selectProcessTemplateByProductIds(productIds);
//    }
//
//
//    /**
//     * 删除项目策划
//     * 只能删除未审核的策划
//     *
//     * @param planningId 策划ID
//     * @return 影响行数
//     */
//    @Override
//    @Transactional
//    public int deleteProjectPlanning(String planningId) {
//        // 1. 检查策划状态
//        ProjectPlanningVO planning = planningMapper.selectProjectPlanningById(planningId);
//        if (planning == null) {
//            throw new RuntimeException("策划不存在");
//        }
//        if (!"0".equals(planning.getAuditState())) {
//            throw new RuntimeException("只能删除未审核的策划");
//        }
//
//        // 2. 删除所有用途类型的关联数据
//        deleteWithTypes(planningId, UseTypeEnum.values());
//
//        // 3. 删除策划主表数据
//        return planningMapper.deleteProjectPlanningById(planningId);
//    }
//
//    /**
//     * 提交项目策划审核
//     */
//    @Override
//    @Transactional
//    public int submitForApproval(ProjectPlanningDTO planningDTO) {
//        // 1. 设置审核状态为审核中
//        planningDTO.setAuditState("1");
//
//        // 2. 保存或更新策划信息
//        int rows;
//        if (planningDTO.getPlanningId() != null) {
//            rows = updateProjectPlanning(planningDTO);
//        } else {
//            rows = insertProjectPlanning(planningDTO);
//        }
//
//        if (rows > 0) {
//            // 3. 启动流程实例
//            RuntimeService runtimeService = flowServiceFactory.getRuntimeService();
//
//            // 设置流程变量
//            String currentUsername = SecurityUtils.getUsername();
//            String userId = SecurityUtils.getUserId().toString();
//
//            log.info("准备启动流程 - 当前用户ID: {}, 用户名: {}", userId, currentUsername);
//            if (flowServiceFactory.getIdentityService() == null) {
//                log.error("identityService未被正确注入!");
//                throw new RuntimeException("identityService未被正确注入");
//            }
//
//            try {
//                // 设置流程发起人ID
//                flowServiceFactory.getIdentityService().setAuthenticatedUserId(userId);
//                log.info("已设置认证用户ID: {}", userId);
//
//                ProcessInstance processInstance = runtimeService.createProcessInstanceBuilder()
//                    .processDefinitionKey("flow_mjkg8gfn")
//                    .name("项目策划审批-" + planningDTO.getProjectName())
//                    .variable("planningId", planningDTO.getPlanningId())
//                    .variable("submitter", currentUsername)
//                    .variable("approvalResult", null)
//                    .variable("approvalComments", null)
//                    .start();
//
//                log.info("流程启动成功 - 流程实例ID: {}, 发起人ID: {}",
//                    processInstance.getId(), processInstance.getStartUserId());
//
//                // 清除设置的发起人ID
//                flowServiceFactory.getIdentityService().setAuthenticatedUserId(null);
//
//                // 记录日志
//                log.info("启动项目策划审批流程 - 流程实例ID: {}, 策划ID: {}",
//                    processInstance.getId(), planningDTO.getPlanningId());
//            } catch (Exception e) {
//                log.error("流程启动失败", e);
//                throw e;
//            }
//        }
//
//        return rows;
//    }
}